package controller

import (
	"github.com/gin-gonic/gin"
	"go_batch_create_orders/admin/model"
	"go_batch_create_orders/admin/service"
	"go_batch_create_orders/admin/validation"
	"go_batch_create_orders/common"
)

//添加规格分类
func AddItemBefore(ctx *gin.Context) {
	specItemQuery := model.QueryList{}
	specItemQuery.Page = 1
	specItemQuery.PageSize = 100
	service := new(service.SpecService)
	res, err := service.GetCategoryList(&specItemQuery)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	common.JsonSuccess(res, "查询成功", ctx)
}

//添加规格属性
func AddSpec(ctx *gin.Context) {
	specItem := model.SpecItem{}
	err := ctx.ShouldBindJSON(&specItem)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	specValidate := new(validation.SpecValidation)
	err = specValidate.ValidateItemAdd(specItem)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	service := new(service.SpecService)
	res, err := service.AddItem(&specItem)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	if res > 0 {
		common.JsonSuccess(res, "添加成功", ctx)
		return
	}
	common.JsonError("添加失败", ctx)
}

func GetItemInfo(ctx *gin.Context) {
	id, b := ctx.GetQuery("id")
	if b == false {
		common.JsonError("参数错误", ctx)
		return
	}
	service := new(service.SpecService)
	newId, err := common.StringToInt(id)
	if err != nil {
		common.JsonError("参数错误", ctx)
		return
	}
	info, err := service.GetItemInfo(newId)
	if err != nil {
		common.JsonError("参数错误", ctx)
		return
	}

	common.JsonSuccess(info, "获取成功", ctx)
	return
}

func UpdateSpec(ctx *gin.Context) {
	specItem := model.SpecItem{}
	err := ctx.ShouldBindJSON(&specItem)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	specValidate := new(validation.SpecValidation)
	err = specValidate.ValidateItemUpdate(specItem)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	specItem.UpdateTime = common.Time()
	service := new(service.SpecService)
	res, err := service.UpdateItem(&specItem)
	if err != nil || res == 0 {
		common.JsonError("修改失败", ctx)
		return
	}
	common.JsonSuccess(res, "修改成功", ctx)
	return
}

func DeleteSpec(ctx *gin.Context) {
	id, b := ctx.GetQuery("id")
	if b == false {
		common.JsonError("缺少参数", ctx)
		return
	}
	newId, err := common.StringToInt64(id)
	if err != nil {
		common.JsonError("参数错误", ctx)
		return
	}
	specItem := model.SpecItem{}
	specItem.Id = newId
	specItem.DeleteTime = common.Time()
	service := new(service.SpecService)
	res, err := service.UpdateItem(&specItem)
	if err != nil || res == 0 {
		common.JsonError("删除失败", ctx)
		return
	}
	common.JsonSuccess(res, "删除成功", ctx)
	return
}

func GetSpecList(ctx *gin.Context) {
	specItemQuery := model.QueryList{}
	err := ctx.ShouldBind(&specItemQuery)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	service := new(service.SpecService)
	res, err := service.GetItemList(&specItemQuery)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	common.JsonSuccess(res, "查询成功", ctx)
}

//添加规格模型
func AddModel(ctx *gin.Context) {
	specModel := model.SpecModel{}
	err := ctx.ShouldBindJSON(&specModel)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	specValidate := new(validation.SpecValidation)
	err = specValidate.ValidateModelAdd(specModel)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	service := new(service.SpecService)
	res, err := service.AddModel(&specModel)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	if res > 0 {
		common.JsonSuccess(res, "添加成功", ctx)
		return
	}
	common.JsonError("添加失败", ctx)
}

func UpdateModel(ctx *gin.Context) {
	//id, exists := ctx.Get("id")
	specModel := model.SpecModel{}
	err := ctx.ShouldBindJSON(&specModel)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	specValidate := new(validation.SpecValidation)
	err = specValidate.ValidateModelUpdate(specModel)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	specModel.UpdateTime = common.Time()
	service := new(service.SpecService)
	res, err := service.UpdateModel(&specModel)
	if err != nil || res == 0 {
		common.JsonError("修改失败", ctx)
		return
	}
	common.JsonSuccess(res, "修改成功", ctx)
	return

}

func DeleteModel(ctx *gin.Context) {
	id, b := ctx.GetQuery("id")
	if b == false {
		common.JsonError("缺少参数", ctx)
		return
	}
	newId, err := common.StringToInt64(id)
	if err != nil {
		common.JsonError("参数错误", ctx)
		return
	}
	specModel := model.SpecModel{}
	specModel.Id = newId
	specModel.DeleteTime = common.Time()
	service := new(service.SpecService)
	res, err := service.UpdateModel(&specModel)
	if err != nil || res == 0 {
		common.JsonError("删除失败", ctx)
		return
	}
	common.JsonSuccess(res, "删除成功", ctx)
	return
}

func GetModelList(ctx *gin.Context) {
	specModelQuery := model.QueryList{}
	err := ctx.ShouldBind(&specModelQuery)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	service := new(service.SpecService)
	res, err := service.GetModelList(&specModelQuery)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	common.JsonSuccess(res, "查询成功", ctx)
}

//添加规格分类
func AddCategoryBefore(ctx *gin.Context) {
	specModelQuery := model.QueryList{}
	specModelQuery.Page = 1
	specModelQuery.PageSize = 100
	service := new(service.SpecService)
	res, err := service.GetModelList(&specModelQuery)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	common.JsonSuccess(res, "查询成功", ctx)
}

//添加规格分类
func AddCategory(ctx *gin.Context) {
	specCateGory := model.SpecCateGory{}
	err := ctx.ShouldBindJSON(&specCateGory)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	specValidate := new(validation.SpecValidation)
	err = specValidate.ValidateCateGoryAdd(specCateGory)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	service := new(service.SpecService)
	res, err := service.AddCategory(&specCateGory)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	if res > 0 {
		common.JsonSuccess(res, "添加成功", ctx)
		return
	}
	common.JsonError("添加失败", ctx)
}

func UpdateCategory(ctx *gin.Context) {
	specCateGory := model.SpecCateGory{}
	err := ctx.ShouldBindJSON(&specCateGory)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	specValidate := new(validation.SpecValidation)
	err = specValidate.ValidateCateGoryUpdate(specCateGory)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	specCateGory.UpdateTime = common.Time()
	service := new(service.SpecService)
	res, err := service.UpdateCategory(&specCateGory)
	if err != nil || res == 0 {
		common.JsonError("修改失败", ctx)
		return
	}
	common.JsonSuccess(res, "修改成功", ctx)
	return
}

func GetCategoryInfo(ctx *gin.Context) {
	id, b := ctx.GetQuery("id")
	if b == false {
		common.JsonError("参数错误", ctx)
		return
	}
	service := new(service.SpecService)
	newId, err := common.StringToInt(id)
	if err != nil {
		common.JsonError("参数错误", ctx)
		return
	}
	info, err := service.GetCategoryInfo(newId)
	if err != nil {
		common.JsonError("参数错误", ctx)
		return
	}

	common.JsonSuccess(info, "获取成功", ctx)
	return
}

func DeleteCategory(ctx *gin.Context) {
	id, b := ctx.GetQuery("id")
	if b == false {
		common.JsonError("缺少参数", ctx)
		return
	}
	newId, err := common.StringToInt64(id)
	if err != nil {
		common.JsonError("参数错误", ctx)
		return
	}
	specCategory := model.SpecCateGory{}
	specCategory.Id = newId
	specCategory.DeleteTime = common.Time()
	service := new(service.SpecService)
	res, err := service.UpdateCategory(&specCategory)
	if err != nil || res == 0 {
		common.JsonError("删除失败", ctx)
		return
	}
	common.JsonSuccess(res, "删除成功", ctx)
	return
}

func GetCategoryList(ctx *gin.Context) {
	specCategoryQuery := model.QueryList{}
	err := ctx.ShouldBind(&specCategoryQuery)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	service := new(service.SpecService)
	res, err := service.GetCategoryList(&specCategoryQuery)
	if err != nil {
		common.JsonError(err.Error(), ctx)
		return
	}
	common.JsonSuccess(res, "查询成功", ctx)
}
